Untransformed display lists in a tile based rendering system

ABSTRACT

3-D rendering systems include a rasterization section that can fetch untransformed geometry, transform geometry and cache data for transformed geometry in a memory. As an example, the rasterization section can transform the geometry into screen space. The geometry can include one or more of static geometry and dynamic geometry. The rasterization section can query the cache for presence of data pertaining to a specific element or elements of geometry, and use that data from the cache, if present, and otherwise perform the transformation again, for actions such as hidden surface removal. The rasterization section can receive, from a geometry processing section, tiled geometry lists and perform the hidden surface removal for pixels within respective tiles to which those lists pertain.

This invention relates to a three-dimensional computer graphicsrendering system and in particular to methods and apparatus associatedwith rendering three-dimensional graphic images utilising anuntransformed display list within a tile based rendering system.

BACKGROUND TO THE INVENTION

Tile based rendering systems are well known, these subdivide an imageinto a plurality of rectangular blocks or tiles in order to increaseefficiency of the rasterisation process.

FIG. 1 illustrates a traditional the based rendering system. Tile basedrendering systems operate in two phases, a geometry processing phase anda rasterisation phase. During the geometry processing phase aprimitive/command fetch unit 100 retrieves command and primitive datafrom memory and passes this to a geometry fetch unit 105 which fetchesthe geometry data 110 from memory and passes it to a transform unit 115.This transforms the primitive and command data into screen space andapplies any lighting/attribute processing as required using well-knownmethods. The resulting data is passed to a culling unit 120 which cullsany geometry that isn't visible using well known methods. The cullingunit writes any remaining geometry data to the transformed parameterbuffer 135 and also passes the position data of the remaining geometryto the tiling unit 125 which generates a set of screen space objectslists for each tile which are written to the tiled geometry lists 130.Each object list contains references to the transformed primitives thatexist wholly or partially in that tile. The lists exist for every tileon the screen, although some object lists may have no data in them. Thisprocess continues until all the geometry within the scene has beenprocessed.

During the rasterisation phase the object lists are fetched by a tiledparameter fetch unit 140 which first fetches the object references andthen the object data referenced and supplies them to a hidden surfaceremoval unit (HSR) 145 which removes surfaces which will not contributeto the final scene (usually because they are obscured by anothersurface). The HSR unit processes each primitive in the tile and passesonly data for visible primitives/pixels to a texturing and shading unit(TSU) 150. The TSU takes the data from the HSR unit and uses it to fetchtextures and apply shading to each pixel within a visible object usingwell-known techniques. The TSU then supplies the textured and shadeddata to an alpha test/fogging/alpha blending unit 155. This is able toapply degrees of transparency/opacity to the surfaces again usingwell-known techniques. Alpha blending is performed using an on chip tilebuffer 160 thereby eliminating the requirement to access external memoryfor this operation. It should be noted that the TSU and alphatest/fogging/alpha blend units may be fully programmable in nature.

Once each tile has been completed, a pixel processing unit 165 performsany necessary backend processing such as packing and anti-aliasfiltering before writing the resulting data to a rendered scene buffer170, ready for display.

Typically modern computer graphics applications utilise a significantamount of geometry that remains static throughout a scene or acrossmultiple scenes, this geometry data is stored in what is commonly knownas static vertex buffers that typically reside in memory that is localto the graphics processing unit. Current tile based systems transformthis data into screen space and store the resulting geometry within aparameter buffer/tiled screen spaced geometry list that can consume aconsiderable amount of additional storage and memory bandwidth.

SUMMARY OF THE INVENTION

Preferred embodiments of the present invention provide a method andapparatus that allow a the based rendering system to operate with areduced amount of storage required for tiled screen space geometry. Thisis accomplished by the use of an untransformed display list to representthe scene's geometry. This removes the need for the transformedparameter buffer 135 in FIG. 1 by utilising the fact that the incomingscene geometry is static and so it can be referenced in both thegeometry processing and rasterisation phases.

BRIEF DESCRIPTION OF THE DRAWINGS

Preferred embodiments of the invention will now be described in detailby way of example with reference to the accompanying drawings in which:

FIG. 1 illustrates a traditional tile based rendering system;

FIG. 2 illustrates a tile based rendering system using an untransformeddisplay list;

FIG. 3 illustrates deferred lighting/attribute processing;

FIG. 4 illustrates the addition of a transformed data cache to thesystem; and

FIG. 5 illustrates a hybrid transformed/untransformed display list basedtile based rendering system.

DETAILED DESCRIPTION OF PREFERRED EMBODIMENTS

FIG. 2 illustrates a tile based rendering system that has been modifiedto support an untransformed display list. During the geometry processingphase a primitive/command fetch unit 200 retrieves command and primitivedata from memory and passes this to a position data fetch unit 205 whichfetches a position part of static geometry data from memory 210 andpasses it to transform 1 unit 215. This transforms the primitive intoscreen space only i.e. it does not apply any lighting/attributeprocessing as would occur in the system of FIG. 1. The resulting screenspace position data is passed to a culling unit 220 which culls anygeometry in the same manner as the system of FIG. 1. Unlike the systemof FIG. 1 the culling unit does not write the remaining geometry data toa transformed parameter buffer, instead it only passes the position dataof the remaining geometry to a tiling unit 225.

In the system of FIG. 1, the tiling unit generates references totransformed geometry that has been stored in the transformed parameterbuffer, in the new system the tiling unit generates references to theuntransformed static geometry data which are written to the tiledgeometry lists 230 as before. These references are in the form ofpointers to the geometry data in the memory 210. This process continuesuntil all the geometry within the scene has been processed.

During the rasterisation phase object lists for each tile are fetched bya tiled parameter fetch unit 240 which supplies the static geometryreferences (pointers) from the total geometry lists to untransformedgeometry fetch unit 245 which fetches the untransformed static geometrydata from memory 210 and passes it to the transform 2 unit 250. Thetransform 2 unit retransforms the retrieved data to screen space andapplies any required lighting/attribute processing etc to the geometry.The transformed geometry is then passed to hidden surface removal unit(HSR) 255 which removes surfaces which will not contribute to the finalscene as in the system of FIG. 1. The remaining stages 260 through to280 all operate in the same manner as stages 150 through 170 (in FIG. 1)as described above. [John: should FIG. 2 also include a source ofdynamic geometry?]

In a further optimisation it is possible to defer any lighting orattribute processing that is required after hidden surface removal hasbeen performed. This means that this processing is only applied to thatgeometry which is visible within the final scene giving significantimprovements in both throughput and power consumption. FIG. 3illustrates a modification to the system that implements deferredlighting/attribute processing. Units 300 and 305 operate as describedfor units 240 and 245 of FIG. 2, unlike unit 250 in FIG. 2 the transform2 unit 310 only transforms the position data before passing it onto thehidden surface removal unit 315. The visible primitives emitted by thehidden surface removal unit are then passed to transform 3 unit 320where any lighting/attribute processing is performed. The operation ofunits 325 to 350 is the same as units 145 to 170 in FIG. 1.

It should be noted that each of the three transformation units mentionedabove could all be implemented in a single “universal” unit similar tothat described in our British Patent Application GB-A-2430513. Althoughthe above approaches eliminate the need for a transformed parameterbuffer they have the disadvantage of requiring the position data to betransformed in both phases and for the transformation to be repeated forevery tile that any piece of geometry overlaps. FIG. 4 illustrates amodification to the rasterisation phase of the untransformed displaylist system in which a cache is added in order to minimise the number oftimes the data is retransformed in the rasterisation phase. It should benoted that although FIG. 4 shows a modification with respect to a nondeferred lighting/attribute processing system it is equally applicableto either. As in FIG. 2 the tiled parameter fetch unit 400 fetches thetiled object list references generated in the geometry processing phasefrom memory. The references are passed to a cache control unit 405 whichchecks to see if there is an entry in the transformed data cache memory410 that corresponds to the object reference, if there is the cachecontrol unit reads the data from the cache and passes it to the hiddensurface removal unit 425. If there is no corresponding entry in thecache the cache control unit issues the reference to the untransformedgeometry fetch unit 415 which fetch the data from memory and passes itto the transform 2 unit 420. The transform 2 unit transforms and appliesany lighting/attribute process required to the geometry data and thenpasses it back to the cache control unit. The cache control unit thenadds it to the transformed data cache memory for future reference beforepassing it to the hidden surface removal unit. The operation of units425 to 450 is the same as units 145 to 170 in FIG. 1.

In order to eliminate the additional geometry processing pass used inthe above approach the result of the position transform can be stored ina parameter buffer for use in the second pass. Although this results inthe need for, transformed parameter storage it may be consider a usefultrade off compared against transforming the position data multipletimes. It should also be noted that there are cases were an applicationwill update the vertex data during a scene, this type of vertex data isoften referred to as dynamic, in these circumstances the data must betransformed and copied to a parameter buffer as per a conventional tilebased rendering device.

FIG. 5 illustrates a hybrid system that allows the use of bothuntransformed and transformed display lists. During the geometryprocessing phase a primitive/command fetch unit 500 retrieves commandand primitive data from memory and passes this to the geometry fetchunit 505 which fetches both the dynamic geometry data 507 and staticgeometry data 510 from memory and passes it to the transform 1 unit 515.

For dynamic geometry the transform 1 unit transforms the position andapplies any required lighting/attribute processing as per a traditionaltile based rendering system, for static geometry only the position istransformed as previously described. The resulting data is passed to aculling unit 520 which culls any geometry that isn't visible using wellknown methods. The culling unit writes any remaining dynamic geometryand static position data to the transformed parameter buffer 535 andalso passes the position data of the remaining geometry to the tilingunit 525 which generates a set of screen objects lists for each tilewhich are written to the tiled geometry lists 530. It should be notedthat the tiled geometry lists indicate which geometry is dynamic andwhich is static. As in FIG. 2 the tiled parameter fetch unit 540 fetchesthe tiled object list references generated in the geometry processingphase from memory. The references are passed to the cache control unit545 which checks to see if there is an entry in the transformed datacache memory 550 that corresponds to the object reference, if there isthe cache control unit reads the data from the cache and passes it tothe hidden surface removal unit 565. If there is no corresponding entryin the cache the cache control unit issues the reference to either thetransformed parameter fetch unit 547 or the untransformed geometry fetchunit 555 based on the type indicated in the tiled reference lists.Transformed geometry is fetched by the transformed parameter fetch unitand passed back to the cache control unit and untransformed geometry isfetched by the untransformed geometry fetch unit and processed bytransform unit 2 560 before being passed back to the cache control unit.Both geometry types are then written to the cache by the control unitbefore being passed to the hidden surface removal unit. All subsequentunits 565 through to 590 operate as previously described for units 145through 170 in FIG. 1.

The invention claimed is:
 1. A method of rendering primitives in a tilebased computer graphics rendering system, wherein the method comprises ageometry processing phase and a rasterisation phase, wherein thegeometry processing phase comprises the steps of: retrieving positiondata of primitives stored in a memory; transforming the retrievedposition data to screen space; and using the screen space position datato generate, for each of a plurality of tiles of the tile basedrendering system, a list of pointers to primitives in the memory whichwhen transformed are at least partially in the respective tile; andwherein the rasterisation phase comprises the steps of: for each of thetiles, retrieving pointers from the respective list; retrieving data ofprimitives from the memory corresponding to the retrieved pointers ofeach list; transforming the retrieved data of primitives to screenspace; and rendering the primitives.
 2. The method of claim 1 whereinthe rasterisation phase further comprises applying attribute processingand applying hidden surface removal.
 3. The method of claim 2 whereinthe attribute processing is applied after the hidden surface removal. 4.The method of claim 1 wherein said transforming the retrieved data ofprimitives to screen space in the rasterisation phase includes storingtransformed data in a cache.
 5. The method of claim 4 wherein saidretrieving data of primitives in the rasterisation phase includeschecking whether transformed data corresponding to data to be retrievedis not present in the cache, and in response thereto performing theretrieval of the data from the memory.
 6. The method of claim 1 whereinthe primitives are static geometric primitives.
 7. The method of claim1, wherein the geometry processing phase further comprises: retrievingdata of dynamic geometric primitives from a second memory; transformingthe retrieved data of the dynamic geometric primitives to screen space;and storing the transformed data for the dynamic geometric primitives;wherein said generating comprises generating, for each of the pluralityof tiles of the tile based rendering system, a list of pointers totransformed data for the dynamic geometric primitives which are at leastpartially in the respective tile and pointers to the primitives in thememory which when transformed are at least partially in the respectivetile; and wherein the rasterisation phase further comprises retrievingstored transformed data for the dynamic geometric primitives.
 8. A tilebased computer graphics rendering system configured to operate in ageometry processing phase and a rasterisation phase, wherein foroperating in the geometry processing phase, the system comprises: afetch unit configured to retrieve position data of primitives stored ina memory; a first transform unit configured to transform retrievedposition data to screen space; a tiling unit configured to use thescreen space position data to generate, for each of a plurality of tilesof the tile based rendering system, a list of pointers to primitives inthe memory which when transformed are at least partially in therespective tile; and wherein for operating in the rasterization phase,the system comprises: a parameter fetch unit configured to retrieve, foreach of the tiles, pointers from the respective list; a geometry fetchunit configured to retrieve data of primitives from the memorycorresponding to the retrieved pointers of each list; a second transformunit configured to transform the retrieved data of primitives to screenspace; and one or more processing units configured to render theprimitives.
 9. The rendering system of claim 8 wherein the one or moreprocessing units comprises one or more of: a hidden surface removal unitconfigured to apply hidden surface removal, a texturing and shading unitconfigured to apply one or both of texturing and shading, an alphaprocessing unit configured to apply degrees of transparency to primitivesurfaces, and a pixel processing unit configured to apply backendprocessing.
 10. The rendering system of claim 9 wherein the processingunits are arranged such that primitives are processed by the hiddensurface removal unit before being processed by the texturing and shadingunit.
 11. The rendering system of claim 8 further comprising a cacheconfigured to store transformed data.
 12. The rendering system of claim11 further comprising a cache control unit configured to check whethertransformed data corresponding to the data to be retrieved is notpresent in the cache, and in response thereto cause the geometry fetchunit to retrieve data of primitives from the memory and pass theretrieved data to the second transform unit.
 13. The rendering system ofclaim 8 wherein the primitives are static geometric primitives.
 14. Therendering system according to claim 8 wherein: the fetch unit is furtherconfigured to retrieve data of dynamic geometric primitives from asecond memory; the first transform unit is further configured totransform the retrieved data of the dynamic geometric primitives toscreen space; the system further comprises a buffer configured to storetransformed data for the dynamic geometric primitives; and wherein thetiling unit is further configured to generate, for each of the pluralityof tiles of the tile based rendering system a list of pointers totransformed data for the dynamic geometric primitives which are at leastpartially in the respective tile and pointers to the primitives in thememory which when transformed are at least partially in the respectivetile; wherein the rendering system further includes a further parameterfetch unit configured to retrieve stored transformed data for thedynamic geometric primitives.
 15. A computer graphics processing unitcomprising: a fetch unit configured to retrieve position data ofprimitives stored in a memory; a first transform unit configured totransform retrieved position data to screen space; a tiling unitconfigured to use the screen space position data to generate, for eachof a plurality of tiles, a list of pointers to primitives in the memorywhich when transformed are at least partially in the respective tile; aparameter fetch unit configured to retrieve, for each of the tiles,pointers from the respective list; a geometry fetch unit configured toretrieve data of primitives from the memory corresponding to theretrieved pointers of each list; a second transform unit configured totransform the retrieved data of primitives to screen space; and one ormore processing units configured to render the primitives.